Node Js

const crypto = require('crypto');

// Generate a key from a password using PBKDF2
function getKeyFromPassword(password, salt) {
    return new Promise((resolve, reject) => {
        crypto.pbkdf2(password, salt, 65536, 32, 'sha256', (err, key) => {
            if (err) reject(err);
            resolve(key)
;
        });
    });
}

// Encrypt plaintext using AES/CBC/PKCS5Padding
async function encryptPasswordBased(plainText, key, iv) {
    return new Promise((resolve, reject) => {
        try {
            const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
            let encrypted = cipher.update(plainText, 'utf8', 'base64');
            encrypted += cipher.final('base64');
            resolve(encrypted);
        } catch (err) {
            reject(err);
        }
    });
}

// Decrypt ciphertext using AES/CBC/PKCS5Padding
async function decryptPasswordBased(encryptedText, key, iv) {
    return new Promise((resolve, reject) => {
        try {
            const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
            let decrypted = decipher.update(encryptedText, 'base64', 'utf8');
            decrypted += decipher.final('utf8');
            resolve(decrypted);
        } catch (err) {
            reject(err);
        }
    });
}

// Function to Base64 encode and then encrypt
async function encrypt(stringToEncrypt, password, salt) {
    try {
        // Base64 encode the plaintext
        const base64Encoded = Buffer.from(stringToEncrypt).toString('base64');
        console.log('Base64 Encoded:', base64Encoded);

        // Generate a 16-byte zero-filled IV
        const iv = Buffer.alloc(16, 0);

        // Get key from password
        const key = await getKeyFromPassword(password, salt);
        console.log('Derived Key:', key.toString('hex'));

        // Encrypt the base64-encoded plaintext
        const encrypted = await encryptPasswordBased(base64Encoded, key, iv);
        console.log('Encrypted:', encrypted);

        return encrypted;
    } catch (ex) {
        console.error('Encryption failed:', ex);
        throw new Error('Encryption failed');
    }
}

// Function to Decrypt and then Base64 decode
async function decrypt(encryptedText, password, salt) {
    try {
        // Generate a 16-byte zero-filled IV
        const iv = Buffer.alloc(16, 0);

        // Get key from password
        const key = await getKeyFromPassword(password, salt);
        console.log('Derived Key:', key.toString('hex'));

        // Decrypt the ciphertext
        const decryptedBase64 = await decryptPasswordBased(encryptedText, key, iv);
        console.log('Decrypted Base64:', decryptedBase64);

        // Base64 decode the decrypted plaintext
        const decrypted = Buffer.from(decryptedBase64, 'base64').toString('utf8');
        console.log('Decrypted:', decrypted);

        return decrypted;
    } catch (ex) {
        console.error('Decryption failed:', ex);
        throw new Error('Decryption failed');
    }
}

// Example usage:
(async () => {
    const password = 'your encryption key';
    const salt = 'your aoi key';

    const plainText = 'things to test';

    try {
        const encrypted = await encrypt(plainText, password, salt);
        console.log('Encrypted:', encrypted);

        const decrypted = await decrypt(encrypted, password, salt);
        console.log('Decrypted:', decrypted);
    } catch (ex) {
        console.error(ex);
    }
})();